home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / U-Z / VideoToolBox Folder / Demos / TimeCPU.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-13  |  14.7 KB  |  713 lines  |  [TEXT/KAHL]
  1. /*
  2. TimeCPU.c
  3. Denis G. Pelli, 1991-1993
  4. This routine is a demo of Timer.c. It measures the timing of basic CPU
  5. operations and several random number generators. The Fixed data type is
  6. predefined by Apple as a long (i.e. 32 bits) with an assumed decimal point in
  7. the middle.
  8.  
  9. The access to video memory overwrites a small part of your main screen, the
  10. first 40 bytes. This will be in the upper left hand corner of your display, and
  11. will usually be barely noticeable. I like seeing that, as it confirms that the
  12. program really is accessing the video memory.
  13.  
  14. This program requests a memory partition of 900K. It will run in less, but will
  15. then do fewer iterations.
  16.  
  17. The timing seems to be very accurate. It ought to be as accurate as the
  18. frequency of the oscillator in the VIA chip. However, I haven't checked the
  19. timing against a known standard.
  20.  
  21. HISTORY:
  22. 1/91    dgp    wrote it
  23. 2/16/91    dgp    added fpu test, to fail gracefully if compiled with FPU support, but FPU
  24.             is not present.
  25. 3/4/91    dgp    added timing of random number generators
  26. 8/6/91    dgp    added timing of RandFill.
  27. 8/24/91    dgp    Made compatible with THINK C 5.0.
  28. 1/25/92    dgp    Calibrate and correct for the slowness of TimeIt(). 
  29.             Measure and subtract off the small loop overhead.
  30.             Identify machine and compiler.
  31.             Automatically append results to TimeCPU.data file.
  32. 1/29/92    dgp    Time move from memory to video memory, for showing movies.
  33.             Added transcendental functions since Radius 8881 init and System 7.01
  34.             speed them up dramatically and the Quadra is reputed to
  35.             do them very slowly.
  36. 1/30/92    dgp    Access video memory only in 32-bit mode, to avoid crashes.
  37. 3/10/92    dgp    include mc68881.h
  38. 8/19/92    dgp    time the 68881 instructions _sin, _sqrt, _exp, _log
  39.             Use new Timer.c instead of old TimeIt.c
  40. 8/28/92    dgp    updated to use new reentrant Timer.c
  41. 11/18/92 dgp renamed output file to “TimeCPU results”
  42. 1/11/93    dgp    check for presence of 68020. Put Gestalt tests in main, without
  43.             any fpu usage, since program was crashing when fpu was absent
  44.             before getting to the fpu test. (Supposedly that was fixed
  45.             in THINK C 5. Oh well.)
  46. 2/7/93    dgp    added timing of SetPixelsQuickly().
  47. */
  48. #include "VideoToolbox.h"
  49. #include <assert.h>
  50. #include <math.h>
  51. #include <SANE.h>        /* for elems68k() & FRANDX */
  52. #include "mc68881.h"
  53.  
  54. void TimeCPU(void);
  55.  
  56. void main(void)
  57. {
  58.     long value;
  59.  
  60.     Require(gestaltOriginalQD);
  61.     Gestalt(gestaltTimeMgrVersion,&value);
  62.     if(value<gestaltRevisedTimeMgr)PrintfExit("Sorry, your System is too old; I need at least \n"
  63.             "the Revised Time Manager.\n");
  64.     TimeCPU();
  65. }
  66.  
  67. void TimeCPU(void)
  68. {
  69.     int error;
  70.     long n,value,quickDraw;
  71.     short i;
  72.     register long *paL,*pbL,iL,jL,kL,mL;
  73.     long nL,iiL;
  74.     double x,y,z;
  75.     Fixed xF,yF,zF;
  76.     void *buffer,*buffer2;
  77.     char Buffer[32];
  78.     FILE *o[2],*dataFile;
  79.     GDHandle device;
  80.     long startTicks,finalTicks;
  81.     double s,s0,f,overhead;
  82.     Timer *timer;
  83.     
  84.     MaximizeConsoleHeight();
  85.     timer=NewTimer();
  86.     Delay(1,&startTicks);
  87.     StartTimer(timer);
  88.     Delay(60,&finalTicks);
  89.     s=StopTimerSecs(timer);
  90.     printf("The VBL tick frequency is %.2f Hz.\n",(finalTicks-startTicks)/s);
  91.     o[0]=stdout;
  92.     o[1]=dataFile=fopen("TimeCPU results","a");    /* Append to data file */
  93.     if(dataFile!=NULL){
  94.         printf("Key results will be appended to “TimeCPU results” file.\n\n");
  95.         SetFileInfo("TimeCPU results",'TEXT','ttxt');
  96.     }
  97.     else printf("Could not open “TimeCPU results” file\n\n");
  98.     ffprintf(o,"\n%s\n",BreakLines(IdentifyMachine(),80));
  99.     ffprintf(o,"%s\n\n",BreakLines(IdentifyCompiler(),80));
  100.     ffprintf(o,"      Time    Operation\n");
  101.     srand(clock());
  102.     y=sqrt(2.0);
  103.     z=sqrt(3.0);
  104.     kL=y*1000.;
  105.     mL=z*10.;
  106.     RandFill(Buffer,sizeof(Buffer));
  107.         
  108.     n=10000;    /* long arithmetic takes a fraction of a microsecond */
  109.     overhead=0.0;
  110.     StartTimer(timer);
  111.     for(iL=n/10;iL>0;iL--);
  112.     overhead=StopTimerSecs(timer)/n-overhead;    // the loop overhead per operation
  113.  
  114.     Gestalt(gestaltQuickdrawVersion,&quickDraw);
  115.     if(quickDraw>=gestalt8BitQD){
  116.         unsigned long row[100],row2[100];
  117.         int rowLength=100,colors;
  118.         
  119.         n/=10;
  120.         device=GetMainDevice();
  121.         colors=GDCOLORS(device);
  122.         for(i=0;i<rowLength;i++)row[i]=nrand(colors);
  123.         StartTimer(timer);
  124.         for(iL=n;iL>0;iL--) {
  125.             SetDevicePixelsQuickly(device,0,0,row,rowLength);
  126.         }
  127.         s=StopTimerSecs(timer)/n-overhead;
  128.         ffprintf(o,"%7.0f    µs    SetPixelsQuickly(,,,,%d);// %d-bit pixels\n",s*1e6
  129.             ,rowLength,(**(**device).gdPMap).pixelSize);
  130.         n*=10;
  131.  
  132.         n/=10;
  133.         StartTimer(timer);
  134.         for(iL=n;iL>0;iL--) {
  135.             GetDevicePixelsQuickly(device,0,0,row2,rowLength);
  136.         }
  137.         s=StopTimerSecs(timer)/n-overhead;
  138.         ffprintf(o,"%7.0f    µs    GetPixelsQuickly(,,,,%d);// %d-bit pixels\n",s*1e6
  139.             ,rowLength,(**(**device).gdPMap).pixelSize);
  140.         n*=10;
  141.         for(i=0;i<rowLength;i++)if(row2[i]!=row[i])printf("Pixel wrote %ld != read %ld\n"
  142.             ,row[i],row2[i]);
  143.     }
  144.     
  145.     for(;n>0;){
  146.         buffer=NewPtr(sizeof(long)*n);
  147.         if(buffer!=NULL){
  148.             buffer2=NewPtr(sizeof(long)*n);
  149.             if(buffer2!=NULL)break;
  150.             DisposPtr(buffer);
  151.         }
  152.         n/=2;
  153.         printf("Reducing iterations to %ld to fit in available memory.\n",n);
  154.     }
  155.     assert(buffer!=NULL && buffer2!=NULL);
  156.     paL=(long *)buffer;
  157.     pbL=(long *)buffer2;
  158.     StartTimer(timer);
  159.     for(iL=n/10;iL>0;iL--) {
  160.         *paL++=*pbL++;
  161.         *paL++=*pbL++;
  162.         *paL++=*pbL++;
  163.         *paL++=*pbL++;
  164.         *paL++=*pbL++;
  165.         *paL++=*pbL++;
  166.         *paL++=*pbL++;
  167.         *paL++=*pbL++;
  168.         *paL++=*pbL++;
  169.         *paL++=*pbL++;
  170.     }
  171.     s=StopTimerSecs(timer)/n-overhead;
  172.     ffprintf(o,"%7.2f    µs    *paL++=*pbL++;        // long, memory to memory\n",s*1e6);
  173.  
  174.     Gestalt(gestaltQuickdrawVersion,&quickDraw);
  175.     if(quickDraw>=gestalt8BitQD){
  176.         device=GetMainDevice();
  177.         if(device!=NULL){
  178.             paL=(long *)(**(**device).gdPMap).baseAddr;
  179.             if(paL!=NULL){
  180.                 char mode=true32b;
  181.                 long t0;
  182.                 long *pSave=paL;
  183.                 
  184.                 StartTimer(timer);
  185.                 SwapMMUMode(&mode);
  186.                 for(iL=n/10;iL>0;iL--) paL-=10;
  187.                 SwapMMUMode(&mode);
  188.                 s0=StopTimerSecs(timer)/n-overhead;
  189.                 paL=pSave;
  190.                 StartTimer(timer);
  191.                 SwapMMUMode(&mode);
  192.                 for(iL=n/10;iL>0;iL--) {
  193.                     *paL++=*pbL++;
  194.                     *paL++=*pbL++;
  195.                     *paL++=*pbL++;
  196.                     *paL++=*pbL++;
  197.                     *paL++=*pbL++;
  198.                     *paL++=*pbL++;
  199.                     *paL++=*pbL++;
  200.                     *paL++=*pbL++;
  201.                     *paL++=*pbL++;
  202.                     *paL++=*pbL++;
  203.                     paL-=10;
  204.                 }
  205.                 SwapMMUMode(&mode);
  206.                 s=StopTimerSecs(timer)/n-overhead;
  207.                 s-=s0;                                    // remove time for the paL-=10;
  208.                 ffprintf(o,"%7.2f    µs    *paL++=*pbL++;        // long, memory to video memory\n",s*1e6);
  209.             }
  210.         }
  211.     }
  212.     DisposPtr(buffer);
  213.     DisposPtr(buffer2);
  214.  
  215.     StartTimer(timer);
  216.     for(iL=n/10;iL>0;iL--) {
  217.         jL=kL;
  218.         jL=kL;
  219.         jL=kL;
  220.         jL=kL;
  221.         jL=kL;
  222.         jL=kL;
  223.         jL=kL;
  224.         jL=kL;
  225.         jL=kL;
  226.         jL=kL;
  227.     }
  228.     s=StopTimerSecs(timer)/n-overhead;
  229.     ffprintf(o,"%7.2f    µs    jL=kL;            // long, register to register\n",s*1e6);
  230.  
  231.     StartTimer(timer);
  232.     for(iL=n/10;iL>0;iL--) {
  233.         jL=kL>>1;
  234.         jL=kL>>1;
  235.         jL=kL>>1;
  236.         jL=kL>>1;
  237.         jL=kL>>1;
  238.         jL=kL>>1;
  239.         jL=kL>>1;
  240.         jL=kL>>1;
  241.         jL=kL>>1;
  242.         jL=kL>>1;
  243.     }
  244.     s=StopTimerSecs(timer)/n-overhead;
  245.     ffprintf(o,"%7.2f    µs    jL=kL>>1;\n",s*1e6);
  246.  
  247.     StartTimer(timer);
  248.     for(iL=n/10;iL>0;iL--) {
  249.         jL=kL+mL;
  250.         jL=kL+mL;
  251.         jL=kL+mL;
  252.         jL=kL+mL;
  253.         jL=kL+mL;
  254.         jL=kL+mL;
  255.         jL=kL+mL;
  256.         jL=kL+mL;
  257.         jL=kL+mL;
  258.         jL=kL+mL;
  259.     }
  260.     s=StopTimerSecs(timer)/n-overhead;
  261.     ffprintf(o,"%7.2f    µs    jL=kL+mL;\n",s*1e6);
  262.  
  263.     StartTimer(timer);
  264.     for(iL=n/10;iL>0;iL--) {
  265.         jL=kL-mL;
  266.         jL=kL-mL;
  267.         jL=kL-mL;
  268.         jL=kL-mL;
  269.         jL=kL-mL;
  270.         jL=kL-mL;
  271.         jL=kL-mL;
  272.         jL=kL-mL;
  273.         jL=kL-mL;
  274.         jL=kL-mL;
  275.     }
  276.     s=StopTimerSecs(timer)/n-overhead;
  277.     ffprintf(o,"%7.2f    µs    jL=kL-mL;\n",s*1e6);
  278.  
  279.     n/=10;            /* all other operations take at least several microseconds */
  280.     StartTimer(timer);
  281.     for(iL=n/10;iL>0;iL--) {
  282.         jL=kL*mL;
  283.         jL=kL*mL;
  284.         jL=kL*mL;
  285.         jL=kL*mL;
  286.         jL=kL*mL;
  287.         jL=kL*mL;
  288.         jL=kL*mL;
  289.         jL=kL*mL;
  290.         jL=kL*mL;
  291.         jL=kL*mL;
  292.     }
  293.     s=StopTimerSecs(timer)/n-overhead;
  294.     ffprintf(o,"%7.1f    µs    jL=kL*mL;\n",s*1e6);
  295.  
  296.     StartTimer(timer);
  297.     for(iL=n/10;iL>0;iL--) {
  298.         jL=kL/mL;
  299.         jL=kL/mL;
  300.         jL=kL/mL;
  301.         jL=kL/mL;
  302.         jL=kL/mL;
  303.         jL=kL/mL;
  304.         jL=kL/mL;
  305.         jL=kL/mL;
  306.         jL=kL/mL;
  307.         jL=kL/mL;
  308.     }
  309.     s=StopTimerSecs(timer)/n-overhead;
  310.     ffprintf(o,"%7.1f    µs    jL=kL/mL;\n",s*1e6);
  311.  
  312.     StartTimer(timer);
  313.     for(iL=n/10;iL>0;iL--) {
  314.         x=y;
  315.         x=y;
  316.         x=y;
  317.         x=y;
  318.         x=y;
  319.         x=y;
  320.         x=y;
  321.         x=y;
  322.         x=y;
  323.         x=y;
  324.     }
  325.     s=StopTimerSecs(timer)/n-overhead;
  326.     ffprintf(o,"%7.1f    µs    x=y;            // double\n",s*1e6);
  327.  
  328.     StartTimer(timer);
  329.     for(iL=n/10;iL>0;iL--) {
  330.         x=y+z;
  331.         x=y+z;
  332.         x=y+z;
  333.         x=y+z;
  334.         x=y+z;
  335.         x=y+z;
  336.         x=y+z;
  337.         x=y+z;
  338.         x=y+z;
  339.         x=y+z;
  340.     }
  341.     s=StopTimerSecs(timer)/n-overhead;
  342.     ffprintf(o,"%7.1f    µs    x=y+z;\n",s*1e6);
  343.  
  344.     StartTimer(timer);
  345.     for(iL=n/10;iL>0;iL--) {
  346.         x=y-z;
  347.         x=y-z;
  348.         x=y-z;
  349.         x=y-z;
  350.         x=y-z;
  351.         x=y-z;
  352.         x=y-z;
  353.         x=y-z;
  354.         x=y-z;
  355.         x=y-z;
  356.     }
  357.     s=StopTimerSecs(timer)/n-overhead;
  358.     ffprintf(o,"%7.1f    µs    x=y-z;\n",s*1e6);
  359.  
  360.     StartTimer(timer);
  361.     for(iL=n/10;iL>0;iL--) {
  362.         x=y*z;
  363.         x=y*z;
  364.         x=y*z;
  365.         x=y*z;
  366.         x=y*z;
  367.         x=y*z;
  368.         x=y*z;
  369.         x=y*z;
  370.         x=y*z;
  371.         x=y*z;
  372.     }
  373.     s=StopTimerSecs(timer)/n-overhead;
  374.     ffprintf(o,"%7.1f    µs    x=y*z;\n",s*1e6);
  375.  
  376.     StartTimer(timer);
  377.     for(iL=n/10;iL>0;iL--) {
  378.         x=y/z;
  379.         x=y/z;
  380.         x=y/z;
  381.         x=y/z;
  382.         x=y/z;
  383.         x=y/z;
  384.         x=y/z;
  385.         x=y/z;
  386.         x=y/z;
  387.         x=y/z;
  388.     }
  389.     s=StopTimerSecs(timer)/n-overhead;
  390.     ffprintf(o,"%7.1f    µs    x=y/z;\n",s*1e6);
  391.     
  392.     StartTimer(timer);
  393.     for(iL=n/10;iL>0;iL--) {
  394.         x=sin(y);
  395.         x=sin(y);
  396.         x=sin(y);
  397.         x=sin(y);
  398.         x=sin(y);
  399.         x=sin(y);
  400.         x=sin(y);
  401.         x=sin(y);
  402.         x=sin(y);
  403.         x=sin(y);
  404.     }
  405.     s=StopTimerSecs(timer)/n-overhead;
  406.     ffprintf(o,"%7.1f    µs    x=sin(y);\n",s*1e6);
  407.  
  408.     StartTimer(timer);
  409.     for(iL=n/10;iL>0;iL--) {
  410.         x=sqrt(y);
  411.         x=sqrt(y);
  412.         x=sqrt(y);
  413.         x=sqrt(y);
  414.         x=sqrt(y);
  415.         x=sqrt(y);
  416.         x=sqrt(y);
  417.         x=sqrt(y);
  418.         x=sqrt(y);
  419.         x=sqrt(y);
  420.     }
  421.     s=StopTimerSecs(timer)/n-overhead;
  422.     ffprintf(o,"%7.1f    µs    x=sqrt(y);\n",s*1e6);
  423.  
  424.     n/=100;
  425.     StartTimer(timer);
  426.     for(iL=n/10;iL>0;iL--) {
  427.         x=log(y);
  428.         x=log(y);
  429.         x=log(y);
  430.         x=log(y);
  431.         x=log(y);
  432.         x=log(y);
  433.         x=log(y);
  434.         x=log(y);
  435.         x=log(y);
  436.         x=log(y);
  437.     }
  438.     s=StopTimerSecs(timer)/n-overhead;
  439.     ffprintf(o,"%7.1f    µs    x=log(y);\n",s*1e6);
  440.     StartTimer(timer);
  441.     for(iL=n/10;iL>0;iL--) {
  442.         x=exp(y);
  443.         x=exp(y);
  444.         x=exp(y);
  445.         x=exp(y);
  446.         x=exp(y);
  447.         x=exp(y);
  448.         x=exp(y);
  449.         x=exp(y);
  450.         x=exp(y);
  451.         x=exp(y);
  452.     }
  453.     s=StopTimerSecs(timer)/n-overhead;
  454.     ffprintf(o,"%7.1f    µs    x=exp(y);\n",s*1e6);
  455.     n*=100;
  456.  
  457.     #if mc68881
  458.         StartTimer(timer);
  459.         for(iL=n/10;iL>0;iL--) {
  460.             x=_sin(y);
  461.             x=_sin(y);
  462.             x=_sin(y);
  463.             x=_sin(y);
  464.             x=_sin(y);
  465.             x=_sin(y);
  466.             x=_sin(y);
  467.             x=_sin(y);
  468.             x=_sin(y);
  469.             x=_sin(y);
  470.         }
  471.         s=StopTimerSecs(timer)/n-overhead;
  472.         ffprintf(o,"%7.1f    µs    x=_sin(y);\n",s*1e6);
  473.     
  474.         StartTimer(timer);
  475.         for(iL=n/10;iL>0;iL--) {
  476.             x=_sqrt(y);
  477.             x=_sqrt(y);
  478.             x=_sqrt(y);
  479.             x=_sqrt(y);
  480.             x=_sqrt(y);
  481.             x=_sqrt(y);
  482.             x=_sqrt(y);
  483.             x=_sqrt(y);
  484.             x=_sqrt(y);
  485.             x=_sqrt(y);
  486.         }
  487.         s=StopTimerSecs(timer)/n-overhead;
  488.         ffprintf(o,"%7.1f    µs    x=_sqrt(y);\n",s*1e6);
  489.     
  490.         StartTimer(timer);
  491.         for(iL=n/10;iL>0;iL--) {
  492.             x=_log(y);
  493.             x=_log(y);
  494.             x=_log(y);
  495.             x=_log(y);
  496.             x=_log(y);
  497.             x=_log(y);
  498.             x=_log(y);
  499.             x=_log(y);
  500.             x=_log(y);
  501.             x=_log(y);
  502.         }
  503.         s=StopTimerSecs(timer)/n-overhead;
  504.         ffprintf(o,"%7.1f    µs    x=_log(y);\n",s*1e6);
  505.         
  506.         StartTimer(timer);
  507.         for(iL=n/10;iL>0;iL--) {
  508.             x=_exp(y);
  509.             x=_exp(y);
  510.             x=_exp(y);
  511.             x=_exp(y);
  512.             x=_exp(y);
  513.             x=_exp(y);
  514.             x=_exp(y);
  515.             x=_exp(y);
  516.             x=_exp(y);
  517.             x=_exp(y);
  518.         }
  519.         s=StopTimerSecs(timer)/n-overhead;
  520.         ffprintf(o,"%7.1f    µs    x=_exp(y);\n",s*1e6);
  521.     #endif
  522.  
  523.     o[1]=NULL;        /* that's all we want to save in “TimeCPU results” */
  524.  
  525.     yF=zF=0x12341234;
  526.     StartTimer(timer);
  527.     for(iL=n/10;iL>0;iL--) {
  528.         xF=FixMul(yF,zF);
  529.         xF=FixMul(yF,zF);
  530.         xF=FixMul(yF,zF);
  531.         xF=FixMul(yF,zF);
  532.         xF=FixMul(yF,zF);
  533.         xF=FixMul(yF,zF);
  534.         xF=FixMul(yF,zF);
  535.         xF=FixMul(yF,zF);
  536.         xF=FixMul(yF,zF);
  537.         xF=FixMul(yF,zF);
  538.     }
  539.     s=StopTimerSecs(timer)/n-overhead;
  540.     ffprintf(o,"%7.1f    µs    xF=FixMul(yF,zF);    // Fixed\n",s*1e6);
  541.  
  542.     yF=(long)(PI*256);
  543.     zF=(long)(1.1*256);
  544.     StartTimer(timer);
  545.     for(iL=n/10;iL>0;iL--) {
  546.         xF=FixDiv(yF,zF);
  547.         xF=FixDiv(yF,zF);
  548.         xF=FixDiv(yF,zF);
  549.         xF=FixDiv(yF,zF);
  550.         xF=FixDiv(yF,zF);
  551.         xF=FixDiv(yF,zF);
  552.         xF=FixDiv(yF,zF);
  553.         xF=FixDiv(yF,zF);
  554.         xF=FixDiv(yF,zF);
  555.         xF=FixDiv(yF,zF);
  556.     }
  557.     s=StopTimerSecs(timer)/n-overhead;
  558.     ffprintf(o,"%7.1f    µs    xF=FixDiv(yF,zF);\n",s*1e6);
  559.  
  560.     StartTimer(timer);
  561.     for(iL=n/10;iL>0;iL--) {
  562.         xF=FixRatio(123,1234);
  563.         xF=FixRatio(123,1234);
  564.         xF=FixRatio(123,1234);
  565.         xF=FixRatio(123,1234);
  566.         xF=FixRatio(123,1234);
  567.         xF=FixRatio(123,1234);
  568.         xF=FixRatio(123,1234);
  569.         xF=FixRatio(123,1234);
  570.         xF=FixRatio(123,1234);
  571.         xF=FixRatio(123,1234);
  572.     }
  573.     s=StopTimerSecs(timer)/n-overhead;
  574.     ffprintf(o,"%7.1f    µs    xF=FixRatio(123,1234);\n",s*1e6);
  575.  
  576.     StartTimer(timer);
  577.     for(iL=n/10;iL>0;iL--) {
  578.         xF=DoubleToFix(y);
  579.         xF=DoubleToFix(y);
  580.         xF=DoubleToFix(y);
  581.         xF=DoubleToFix(y);
  582.         xF=DoubleToFix(y);
  583.         xF=DoubleToFix(y);
  584.         xF=DoubleToFix(y);
  585.         xF=DoubleToFix(y);
  586.         xF=DoubleToFix(y);
  587.         xF=DoubleToFix(y);
  588.     }
  589.     s=StopTimerSecs(timer)/n-overhead;
  590.     ffprintf(o,"%7.1f    µs    xF=DoubleToFix(y);\n",s*1e6);
  591.  
  592.     xF=(long)(PI*256);
  593.     StartTimer(timer);
  594.     for(iL=n/10;iL>0;iL--) {
  595.         x=FixToDouble(xF);
  596.         x=FixToDouble(xF);
  597.         x=FixToDouble(xF);
  598.         x=FixToDouble(xF);
  599.         x=FixToDouble(xF);
  600.         x=FixToDouble(xF);
  601.         x=FixToDouble(xF);
  602.         x=FixToDouble(xF);
  603.         x=FixToDouble(xF);
  604.         x=FixToDouble(xF);
  605.         x=FixToDouble(xF);
  606.     }
  607.     s=StopTimerSecs(timer)/n-overhead;
  608.     ffprintf(o,"%7.1f    µs    x=FixToDouble(xF);\n",s*1e6);
  609.  
  610.     n*=10;
  611.     for(;n>0;n/=2){
  612.         buffer=NewPtr(n);
  613.         if(buffer!=NULL)break;
  614.     }
  615.     StartTimer(timer);
  616.     s=StopTimerSecs(timer);
  617.     StartTimer(timer);
  618.     RandFill(buffer,n);
  619.     s=StopTimerSecs(timer) - s;
  620.     DisposPtr(buffer);
  621.     ffprintf(o,"%7.1f    ms    RandFill(,%ld);    // i.e. %4.1f µs/byte\n"
  622.         ,s*1e3,n,s*1e6/n);
  623.     n/=10;
  624.  
  625.     StartTimer(timer);
  626.     for(iL=n/10;iL>0;iL--) {
  627.         i=randU();
  628.         i=randU();
  629.         i=randU();
  630.         i=randU();
  631.         i=randU();
  632.         i=randU();
  633.         i=randU();
  634.         i=randU();
  635.         i=randU();
  636.         i=randU();
  637.     }
  638.     s=StopTimerSecs(timer)/n-overhead;
  639.     ffprintf(o,"%7.1f    µs    i=randU();        // i.e. %4.1f µs/byte\n",s*1e6, s*1e6/2.);
  640.  
  641.     StartTimer(timer);
  642.     for(iL=n/10;iL>0;iL--) {
  643.         i=rand();
  644.         i=rand();
  645.         i=rand();
  646.         i=rand();
  647.         i=rand();
  648.         i=rand();
  649.         i=rand();
  650.         i=rand();
  651.         i=rand();
  652.         i=rand();
  653.     }
  654.     s=StopTimerSecs(timer)/n-overhead;
  655.     ffprintf(o,"%7.1f    µs    i=rand();         // i.e. %4.1f µs/byte\n",s*1e6, s*1e6/1.);
  656.  
  657.     StartTimer(timer);
  658.     for(iL=n/10;iL>0;iL--) {
  659.         i=Random();
  660.         i=Random();
  661.         i=Random();
  662.         i=Random();
  663.         i=Random();
  664.         i=Random();
  665.         i=Random();
  666.         i=Random();
  667.         i=Random();
  668.         i=Random();
  669.     }
  670.     s=StopTimerSecs(timer)/n-overhead;
  671.     ffprintf(o,"%7.1f    µs    i=Random();\n",s*1e6);
  672.  
  673.     StartTimer(timer);
  674.     for(iL=n/10;iL>0;iL--) {
  675.         i=nrand(128);
  676.         i=nrand(128);
  677.         i=nrand(128);
  678.         i=nrand(128);
  679.         i=nrand(128);
  680.         i=nrand(128);
  681.         i=nrand(128);
  682.         i=nrand(128);
  683.         i=nrand(128);
  684.         i=nrand(128);
  685.     }
  686.     s=StopTimerSecs(timer)/n-overhead;
  687.     ffprintf(o,"%7.1f    µs    i=nrand(128);\n",s*1e6);
  688.  
  689.     n/=5;
  690.     x=rand();
  691.     elems68k(&x,FRANDX);
  692.     StartTimer(timer);
  693.     for(iL=n/10;iL>0;iL--) {
  694.         elems68k(&x,FRANDX); /* i.e. Randomx() */
  695.         elems68k(&x,FRANDX);
  696.         elems68k(&x,FRANDX);
  697.         elems68k(&x,FRANDX);
  698.         elems68k(&x,FRANDX);
  699.         elems68k(&x,FRANDX);
  700.         elems68k(&x,FRANDX);
  701.         elems68k(&x,FRANDX);
  702.         elems68k(&x,FRANDX);
  703.         elems68k(&x,FRANDX);
  704.     }
  705.     s=StopTimerSecs(timer)/n-overhead;
  706.     ffprintf(o,"%7.1f    µs    elems68k(&x,FRANDX);    // i.e. x=Randomx()\n",s*1e6);
  707.     n*=5;
  708.  
  709.     DisposeTimer(timer);
  710.     fclose(dataFile);    /* close “TimeCPU results” */
  711. }
  712.  
  713.